home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / WinTlb / OLEAUTO.IDL < prev    next >
Text File  |  1996-08-15  |  17KB  |  548 lines
  1.  
  2. // ITypeLib                    
  3.  
  4. typedef ITypeLib * LPTYPELIB;
  5.  
  6.  
  7. // ITypeInfo                    
  8.  
  9. typedef LONG DISPID;
  10. typedef DISPID MEMBERID;
  11.  
  12.  
  13. typedef ITypeInfo * LPTYPEINFO;
  14.  
  15. // ITypeComp                   
  16. typedef ITypeComp * LPTYPECOMP;
  17.  
  18. // ICreateTypeLib                  
  19. typedef ICreateTypeLib * LPCREATETYPELIB;
  20. typedef ICreateTypeInfo * LPCREATETYPEINFO;
  21.  
  22. // IDispatch                   
  23.  
  24. typedef IDispatch * LPDISPATCH;
  25.  
  26. // IDispatch implementation support              
  27. /*
  28. typedef struct PARAMDATA {
  29.     OLECHAR * szName;    // parameter name 
  30.     VARTYPE vt;          // parameter type 
  31. } PARAMDATA, * LPPARAMDATA;
  32.  
  33. typedef struct METHODDATA {
  34.     OLECHAR * szName;    // method name 
  35.     PARAMDATA * ppdata;  // pointer to an array of PARAMDATAs 
  36.     DISPID dispid;       // method ID 
  37.     UINT iMeth;          // method index 
  38.     CALLCONV cc;         // calling convention 
  39.     UINT cArgs;          // count of arguments 
  40.     WORD wFlags;         // same wFlags as on IDispatch::Invoke() 
  41.     VARTYPE vtReturn;
  42. } METHODDATA, * LPMETHODDATA;
  43.  
  44. typedef struct INTERFACEDATA {
  45.     METHODDATA * pmethdata; // pointer to an array of METHODDATAs 
  46.     UINT cMembers;            // count of members 
  47. } INTERFACEDATA, * LPINTERFACEDATA;
  48. */
  49.  
  50. [
  51. #ifdef UNICODE
  52. uuid(6467504A-3A82-101B-8181-00AA003743D3),
  53. #else
  54. uuid(6467404A-3A82-101B-8181-00AA003743D3),
  55. #endif
  56. helpstring("OLE Automation Functions"),
  57. dllname("OLEAUT32.DLL")
  58. ]
  59. module OleAuto {
  60.  
  61.     #define WINOLEAUTAPI        HRESULT WINAPI
  62.     #define WINOLEAUTAPI_(type) type WINAPI
  63.  
  64.     const WORD STDOLE_MAJORVERNUM = 0x1;
  65.     const WORD STDOLE_MINORVERNUM = 0x0;
  66.     const WORD STDOLE_LCID        = 0x0000;
  67.  
  68.     //----------
  69.     // BSTR API
  70.     //----------
  71.  
  72.     [
  73.     usesgetlasterror,
  74.     entry("SysAllocString"),
  75.     helpstring("Allocates and returns a BSTR for a given LPSTR"),
  76.     ]
  77.     BSTR WINAPI SysAllocString(LPTSTR sz);
  78.  
  79.     [
  80.     usesgetlasterror,
  81.     entry("SysReAllocString"),
  82.     helpstring("Reallocates a BSTR, assigning it the value of a given BSTR and freeing the old data (returns true or false)"),
  83.     ]
  84.     BOOL WINAPI SysReAllocString(BSTR pbstr,
  85.                                  LPTSTR sz);
  86.  
  87.     [
  88.     usesgetlasterror,
  89.     entry("SysAllocStringLen"),
  90.     helpstring("Allocates and returns a BSTR using the given number of characters from a given LPSTR"),
  91.     ]
  92.     BSTR WINAPI SysAllocStringLen(LPTSTR sz, UINT len);
  93.  
  94.     [
  95.     usesgetlasterror,
  96.     entry("SysReAllocStringLen"),
  97.     helpstring("Reallocates a BSTR, assigning it a given number of characters from a given BSTR and freeing the old data (returns true or false)"),
  98.     ]
  99.     int  WINAPI SysReAllocStringLen(BSTR pbstr,
  100.                                     LPTSTR pch,
  101.                                     UINT cch);
  102.  
  103.     [
  104.     usesgetlasterror,
  105.     entry("SysFreeString"),
  106.     helpstring("Frees a BSTR"),
  107.     ]
  108.     void WINAPI SysFreeString(BSTR bstr);
  109.  
  110.     [
  111.     usesgetlasterror,
  112.     entry("SysStringLen"),
  113.     helpstring("Returns the length in characters of a BSTR"),
  114.     ]
  115.     UINT WINAPI SysStringLen(BSTR bstr);
  116.  
  117.     [
  118.     usesgetlasterror,
  119.     entry("SysStringByteLen"),
  120.     helpstring("Returns the length in bytes of a BSTR"),
  121.     ]
  122.     UINT WINAPI SysStringByteLen(BSTR bstr);
  123.  
  124.     [
  125.     usesgetlasterror,
  126.     entry("SysAllocStringByteLen"),
  127.     helpstring("Allocates and returns a BSTR using the given number of bytes from a given LPSTR"),
  128.     ]
  129.     BSTR WINAPI SysAllocStringByteLen(LPTSTR psz,
  130.                                       UINT len);
  131.  
  132.     //----------
  133.     // Time API
  134.     //----------
  135.  
  136.     [
  137.     usesgetlasterror,
  138.     entry("DosDateTimeToVariantTime"),
  139.     helpstring("Converts a DOS packed date and time to the floating point format stored in variants"),
  140.     ]
  141.     int WINAPI DosDateTimeToVariantTime(
  142.         unsigned short wDosDate,
  143.         unsigned short wDosTime,
  144.         double * pvtime);
  145.  
  146.     [
  147.     usesgetlasterror,
  148.     entry("VariantTimeToDosDateTime"),
  149.     helpstring("Converts the floating point format stored in variants to a DOS packed date and time"),
  150.     ]
  151.     int WINAPI VariantTimeToDosDateTime(
  152.         double vtime,
  153.         unsigned short * pwDosDate,
  154.         unsigned short * pwDosTime);
  155.  
  156.  
  157.     //---------------
  158.     // SafeArray API
  159.     //---------------
  160.  
  161.     /* SafeArray omitted
  162.  
  163.     STDAPI
  164.     SafeArrayAllocDescriptor(unsigned int cDims, SAFEARRAY * * ppsaOut);
  165.  
  166.     STDAPI SafeArrayAllocData(SAFEARRAY * psa);
  167.  
  168.     STDAPI_(SAFEARRAY *)
  169.     SafeArrayCreate(
  170.         VARTYPE vt,
  171.         unsigned int cDims,
  172.         SAFEARRAYBOUND * rgsabound);
  173.  
  174.     STDAPI SafeArrayDestroyDescriptor(SAFEARRAY * psa);
  175.  
  176.     STDAPI SafeArrayDestroyData(SAFEARRAY * psa);
  177.  
  178.     STDAPI SafeArrayDestroy(SAFEARRAY * psa);
  179.  
  180.     STDAPI SafeArrayRedim(SAFEARRAY * psa, SAFEARRAYBOUND * psaboundNew);
  181.  
  182.     STDAPI_(unsigned int) SafeArrayGetDim(SAFEARRAY * psa);
  183.  
  184.     STDAPI_(unsigned int) SafeArrayGetElemsize(SAFEARRAY * psa);
  185.  
  186.     STDAPI
  187.     SafeArrayGetUBound(SAFEARRAY * psa, unsigned int nDim, long * plUbound);
  188.  
  189.     STDAPI
  190.     SafeArrayGetLBound(SAFEARRAY * psa, unsigned int nDim, long * plLbound);
  191.  
  192.     STDAPI SafeArrayLock(SAFEARRAY * psa);
  193.  
  194.     STDAPI SafeArrayUnlock(SAFEARRAY * psa);
  195.  
  196.     STDAPI SafeArrayAccessData(SAFEARRAY * psa, void HUGEP* * ppvData);
  197.  
  198.     STDAPI SafeArrayUnaccessData(SAFEARRAY * psa);
  199.  
  200.     STDAPI
  201.     SafeArrayGetElement(
  202.         SAFEARRAY * psa,
  203.         long * rgIndices,
  204.         void * pv);
  205.  
  206.     STDAPI
  207.     SafeArrayPutElement(
  208.         SAFEARRAY * psa,
  209.         long * rgIndices,
  210.         void * pv);
  211.  
  212.     STDAPI
  213.     SafeArrayCopy(
  214.         SAFEARRAY * psa,
  215.         SAFEARRAY * * ppsaOut);
  216.     */
  217.  
  218.     //-------------
  219.     // VARIANT API
  220.     //-------------
  221.  
  222.     /* Variant omitted
  223.     STDAPI_(void)
  224.     VariantInit(VARIANTARG * pvarg);
  225.  
  226.     STDAPI
  227.     VariantClear(VARIANTARG * pvarg);
  228.  
  229.     STDAPI
  230.     VariantCopy(
  231.         VARIANTARG * pvargDest,
  232.         VARIANTARG * pvargSrc);
  233.  
  234.     STDAPI
  235.     VariantCopyInd(
  236.         VARIANT * pvarDest,
  237.         VARIANTARG * pvargSrc);
  238.  
  239.     STDAPI
  240.     VariantChangeType(
  241.         VARIANTARG * pvargDest,
  242.         VARIANTARG * pvarSrc,
  243.         unsigned short wFlags,
  244.         VARTYPE vt);
  245.  
  246.     STDAPI
  247.     VariantChangeTypeEx(
  248.         VARIANTARG * pvargDest,
  249.         VARIANTARG * pvarSrc,
  250.         LCID lcid,
  251.         unsigned short wFlags,
  252.         VARTYPE vt);
  253.     
  254.     const long VARIANT_NOVALUEPROP = 1;
  255.     */
  256.  
  257.     //----------------------
  258.     // VARTYPE Coercion API
  259.     //----------------------
  260.  
  261.     // Note: The routines that convert *from* a string are defined
  262.     // to take a char* rather than a BSTR because no allocation is
  263.     // required, and this makes the routines a bit more generic.
  264.     // They may of course still be passed a BSTR as the strIn param.
  265.  
  266.     // Any of the coersion functions that converts either from or to a string
  267.     // takes an additional lcid and dwFlags arguments. The lcid argument allows
  268.     // locale specific parsing to occur.  The dwFlags allow additional function
  269.     // specific condition to occur.  All function that accept the dwFlags argument
  270.     // can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
  271.     // VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and
  272.     // VAR_DATEVALUEONLY flags
  273.  
  274.     /* Omitted
  275.     const DWORD VAR_TIMEVALUEONLY = 0x0001;    // return time value
  276.     const DWORD VAR_DATEVALUEONLY = 0x0002;    // return date value
  277.  
  278.     STDAPI VarI2FromI4(long lIn, short * psOut);
  279.     STDAPI VarI2FromR4(float fltIn, short * psOut);
  280.     STDAPI VarI2FromR8(double dblIn, short * psOut);
  281.     STDAPI VarI2FromCy(CY cyIn, short * psOut);
  282.     STDAPI VarI2FromDate(DATE dateIn, short * psOut);
  283.     STDAPI VarI2FromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, short * psOut);
  284.     STDAPI VarI2FromDisp(IDispatch * pdispIn, LCID lcid, short * psOut);
  285.     STDAPI VarI2FromBool(VARIANT_BOOL boolIn, short * psOut);
  286.  
  287.     STDAPI VarI4FromI2(short sIn, long * plOut);
  288.     STDAPI VarI4FromR4(float fltIn, long * plOut);
  289.     STDAPI VarI4FromR8(double dblIn, long * plOut);
  290.     STDAPI VarI4FromCy(CY cyIn, long * plOut);
  291.     STDAPI VarI4FromDate(DATE dateIn, long * plOut);
  292.     STDAPI VarI4FromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, long * plOut);
  293.     STDAPI VarI4FromDisp(IDispatch * pdispIn, LCID lcid, long * plOut);
  294.     STDAPI VarI4FromBool(VARIANT_BOOL boolIn, long * plOut);
  295.  
  296.     STDAPI VarR4FromI2(short sIn, float * pfltOut);
  297.     STDAPI VarR4FromI4(long lIn, float * pfltOut);
  298.     STDAPI VarR4FromR8(double dblIn, float * pfltOut);
  299.     STDAPI VarR4FromCy(CY cyIn, float * pfltOut);
  300.     STDAPI VarR4FromDate(DATE dateIn, float * pfltOut);
  301.     STDAPI VarR4FromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, float * pfltOut);
  302.     STDAPI VarR4FromDisp(IDispatch * pdispIn, LCID lcid, float * pfltOut);
  303.     STDAPI VarR4FromBool(VARIANT_BOOL boolIn, float * pfltOut);
  304.  
  305.     STDAPI VarR8FromI2(short sIn, double * pdblOut);
  306.     STDAPI VarR8FromI4(long lIn, double * pdblOut);
  307.     STDAPI VarR8FromR4(float fltIn, double * pdblOut);
  308.     STDAPI VarR8FromCy(CY cyIn, double * pdblOut);
  309.     STDAPI VarR8FromDate(DATE dateIn, double * pdblOut);
  310.     STDAPI VarR8FromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, double * pdblOut);
  311.     STDAPI VarR8FromDisp(IDispatch * pdispIn, LCID lcid, double * pdblOut);
  312.     STDAPI VarR8FromBool(VARIANT_BOOL boolIn, double * pdblOut);
  313.  
  314.     STDAPI VarDateFromI2(short sIn, DATE * pdateOut);
  315.     STDAPI VarDateFromI4(long lIn, DATE * pdateOut);
  316.     STDAPI VarDateFromR4(float fltIn, DATE * pdateOut);
  317.     STDAPI VarDateFromR8(double dblIn, DATE * pdateOut);
  318.     STDAPI VarDateFromCy(CY cyIn, DATE * pdateOut);
  319.     STDAPI VarDateFromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, DATE * pdateOut);
  320.     STDAPI VarDateFromDisp(IDispatch * pdispIn, LCID lcid, DATE * pdateOut);
  321.     STDAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE * pdateOut);
  322.  
  323.     STDAPI VarCyFromI2(short sIn, CY * pcyOut);
  324.     STDAPI VarCyFromI4(long lIn, CY * pcyOut);
  325.     STDAPI VarCyFromR4(float fltIn, CY * pcyOut);
  326.     STDAPI VarCyFromR8(double dblIn, CY * pcyOut);
  327.     STDAPI VarCyFromDate(DATE dateIn, CY * pcyOut);
  328.     STDAPI VarCyFromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, CY * pcyOut);
  329.     STDAPI VarCyFromDisp(IDispatch * pdispIn, LCID lcid, CY * pcyOut);
  330.     STDAPI VarCyFromBool(VARIANT_BOOL boolIn, CY * pcyOut);
  331.  
  332.     STDAPI VarBstrFromI2(short iVal, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  333.     STDAPI VarBstrFromI4(long lIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  334.     STDAPI VarBstrFromR4(float fltIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  335.     STDAPI VarBstrFromR8(double dblIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  336.     STDAPI VarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  337.     STDAPI VarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  338.     STDAPI VarBstrFromDisp(IDispatch * pdispIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  339.     STDAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, unsigned long dwFlags, BSTR * pbstrOut);
  340.  
  341.     STDAPI VarBoolFromI2(short sIn, VARIANT_BOOL * pboolOut);
  342.     STDAPI VarBoolFromI4(long lIn, VARIANT_BOOL * pboolOut);
  343.     STDAPI VarBoolFromR4(float fltIn, VARIANT_BOOL * pboolOut);
  344.     STDAPI VarBoolFromR8(double dblIn, VARIANT_BOOL * pboolOut);
  345.     STDAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL * pboolOut);
  346.     STDAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL * pboolOut);
  347.     STDAPI VarBoolFromStr(TCHAR * strIn, LCID lcid, unsigned long dwFlags, VARIANT_BOOL * pboolOut);
  348.     STDAPI VarBoolFromDisp(IDispatch * pdispIn, LCID lcid, VARIANT_BOOL * pboolOut);
  349.     */
  350.  
  351.  
  352.     //define MEMBERID_NIL DISPID_UNKNOWN
  353.     const DWORD ID_DEFAULTINST  = -2;
  354.  
  355.  
  356.     const DWORD IDLFLAG_NONE    = 0;
  357.     const DWORD IDLFLAG_FIN     = 0x1;
  358.     const DWORD IDLFLAG_FOUT    = 0x2;
  359.     const DWORD IDLFLAG_FLCID   = 0x4;
  360.     const DWORD IDLFLAG_FRETVAL = 0x8;
  361.  
  362.  
  363.     // Flags for IDispatch::Invoke 
  364.     const DWORD DISPATCH_METHOD         = 0x1;
  365.     const DWORD DISPATCH_PROPERTYGET    = 0x2;
  366.     const DWORD DISPATCH_PROPERTYPUT    = 0x4;
  367.     const DWORD DISPATCH_PROPERTYPUTREF = 0x8;
  368.  
  369.     // TypeInfo API                    
  370.  
  371.     /* Omit
  372.     // compute a 16bit hash value for the given name
  373.     WINOLEAUTAPI_(ULONG)
  374.     LHashValOfNameSysA(SYSKIND syskind, LCID lcid, const char * szName);
  375.  
  376.     WINOLEAUTAPI_(ULONG)
  377.     LHashValOfNameSys(SYSKIND syskind, LCID lcid, const OLECHAR * szName);
  378.  
  379.     //define LHashValOfName(lcid, szName) 
  380.             LHashValOfNameSys(SYS_WIN32, lcid, szName)
  381.  
  382.     //define WHashValOfLHashVal(lhashval) 
  383.             ((unsigned short) (0x0000ffff & (lhashval)))
  384.  
  385.     //define IsHashValCompatible(lhashval1, lhashval2) 
  386.             ((BOOL) ((0x00ff0000 & (lhashval1)) == (0x00ff0000 & (lhashval2))))
  387.  
  388.     */
  389.  
  390.     // load the typelib from the file with the given filename
  391.     [
  392.     usesgetlasterror,
  393.     entry("LoadTypeLib"),
  394.     helpstring("Loads and registers a type library"),
  395.     ]
  396.     WINOLEAUTAPI LoadTypeLib(
  397.         LPWSTR wszFile, 
  398.         /* ITypeLib */ IUnknown ** pptlib);
  399.  
  400.     // load registered typelib
  401.     [
  402.     usesgetlasterror,
  403.     entry("LoadRegTypeLib"),
  404.     helpstring("Uses registry information to load a type library"),
  405.     ]
  406.     WINOLEAUTAPI LoadRegTypeLib(
  407.         REFGUID rguid,
  408.         WORD wVerMajor,
  409.         WORD wVerMinor,
  410.         LCID lcid,
  411.         ITypeLib ** pptlib);
  412.  
  413.     // get path to registered typelib
  414.     [
  415.     usesgetlasterror,
  416.     entry("QueryPathOfRegTypeLib"),
  417.     helpstring("Retrieves the path of a registered type library"),
  418.     ]
  419.     WINOLEAUTAPI QueryPathOfRegTypeLib(
  420.         REFGUID guid,
  421.         unsigned short wMaj,
  422.         unsigned short wMin,
  423.         LCID lcid,
  424.         LPBSTR lpbstrPathName);
  425.  
  426.     // add typelib to registry
  427.     [
  428.     usesgetlasterror,
  429.     entry("RegisterTypeLib"),
  430.     helpstring("Adds information about a type library to the system registry"),
  431.     ]
  432.     WINOLEAUTAPI RegisterTypeLib(
  433.         /* ITypeLib */ IUnknown * ptlib, 
  434.         LPWSTR wszFullPath,
  435.         LPWSTR wszHelpDir);
  436.  
  437.     // remove typelib from registry
  438.     [
  439.     usesgetlasterror,
  440.     entry("DeregisterTypeLib"),
  441.     helpstring("Deregisters a type library"),
  442.     ]
  443.     WINOLEAUTAPI DeregisterTypeLib(
  444.         REFGUID rguid, 
  445.         WORD wVerMajor, 
  446.         WORD wVerMinor, 
  447.         LCID lcid);
  448.  
  449.     [
  450.     usesgetlasterror,
  451.     entry("CreateTypeLib"),
  452.     helpstring("Sets its output parameter (ppctlib) to point to a newly created object that supports the ICreateTypeLib interface"),
  453.     ]
  454.     WINOLEAUTAPI CreateTypeLib(
  455.         SYSKIND syskind, 
  456.         OLECHAR * szFile,
  457.         ICreateTypeLib * * ppctlib);
  458.  
  459. #if 0
  460.     // Locate the parameter indicated by the given position, and
  461.     // return it coerced to the given target VARTYPE (vtTarg).
  462.  
  463.     /*         
  464.     WINOLEAUTAPI
  465.     DispGetParam(
  466.         DISPPARAMS * pdispparams,
  467.         UINT position,
  468.         VARTYPE vtTarg,
  469.         VARIANT * pvarResult,
  470.         UINT * puArgErr);
  471.  
  472.     // Automatic TypeInfo driven implementation of IDispatch::GetIDsOfNames()
  473.      
  474.     WINOLEAUTAPI
  475.     DispGetIDsOfNames(
  476.         ITypeInfo * ptinfo,
  477.         OLECHAR * * rgszNames,
  478.         UINT cNames,
  479.         DISPID * rgdispid);
  480.  
  481.     // Automatic TypeInfo driven implementation of IDispatch::Invoke()
  482.      
  483.     WINOLEAUTAPI
  484.     DispInvoke(
  485.         void * _this,
  486.         ITypeInfo * ptinfo,
  487.         DISPID dispidMember,
  488.         WORD wFlags,
  489.         DISPPARAMS * pparams,
  490.         VARIANT * pvarResult,
  491.         EXCEPINFO * pexcepinfo,
  492.         UINT * puArgErr);
  493.  
  494.     // Construct a TypeInfo from an interface data description
  495.     WINOLEAUTAPI
  496.     CreateDispTypeInfo(
  497.         INTERFACEDATA * pidata,
  498.         LCID lcid,
  499.         ITypeInfo * * pptinfo);
  500.  
  501.     // Create an instance of the standard TypeInfo driven IDispatch
  502.     // implementation.
  503.     WINOLEAUTAPI
  504.     CreateStdDispatch(
  505.         IUnknown * punkOuter,
  506.         void * pvThis,
  507.         ITypeInfo * ptinfo,
  508.         IUnknown * * ppunkStdDisp);
  509.  
  510.  
  511.     // Active Object Registration API               
  512.  
  513.     // Flags for RegisterActiveObject 
  514.     const DWORD ACTIVEOBJECT_STRONG 0x0
  515.     const DWORD ACTIVEOBJECT_WEAK 0x1
  516.  
  517.     WINOLEAUTAPI
  518.     RegisterActiveObject(
  519.        IUnknown * punk,
  520.        REFCLSID rclsid,
  521.        DWORD dwFlags,
  522.        DWORD * pdwRegister);
  523.  
  524.     WINOLEAUTAPI
  525.     RevokeActiveObject(
  526.         DWORD dwRegister,
  527.         void * pvReserved);
  528.  
  529.     WINOLEAUTAPI
  530.     GetActiveObject(
  531.         REFCLSID rclsid,
  532.         void * pvReserved,
  533.         IUnknown * * ppunk);
  534.  
  535.     // ErrorInfo API                             
  536.  
  537.     WINOLEAUTAPI SetErrorInfo(unsigned long dwReserved, IErrorInfo * perrinfo);
  538.     WINOLEAUTAPI GetErrorInfo(unsigned long dwReserved, IErrorInfo * * pperrinfo);
  539.     WINOLEAUTAPI CreateErrorInfo(ICreateErrorInfo * * pperrinfo);
  540.  
  541.     // MISC API                                  
  542.  
  543.     WINOLEAUTAPI_(unsigned long) OaBuildVersion(void);
  544.     */
  545. #endif
  546.  
  547. }
  548.